// 购物车状态管理

import { ref, computed } from 'vue'
import { defineStore } from 'pinia'
import { getCartItems, saveCartItem, updateCartItem, deleteCartItems } from '@/api/cart'
import type { CartItem } from '@/types/cart'
import { useUserStore } from './user'

export const useCartStore = defineStore('cart', () => {
  // 状态
  const cartItems = ref<CartItem[]>([])
  const loading = ref(false)
  
  // 计算属性
  const totalItems = computed(() => {
    return cartItems.value.reduce((total, item) => total + item.quantity, 0)
  })
  
  const totalPrice = computed(() => {
    return cartItems.value.reduce((total, item) => {
      const itemTotal = (item.product?.price || 0) * item.quantity
      return total + itemTotal
    }, 0)
  })
  
  // 获取购物车列表
  const fetchCartItems = async () => {
    const userStore = useUserStore()
    if (!userStore.userInfo?.id) {
      return
    }
    
    try {
      loading.value = true
      const response = await getCartItems(Number(userStore.userInfo.id))
      
      // 确保只显示属于当前用户的购物车项（前端二次过滤）
      const currentUserId = Number(userStore.userInfo.id)
      const userCartItems = response.data?.filter(item => {
        const itemUserId = Number(item.userId)
        return itemUserId === currentUserId
      }) || []
      
      cartItems.value = userCartItems
    } catch (error) {
      console.error('获取购物车失败:', error)
    } finally {
      loading.value = false
    }
  }
  
  // 添加商品到购物车
  const addToCart = async (productId: number, quantity: number = 1) => {
    const userStore = useUserStore()
    if (!userStore.userInfo?.id) {
      throw new Error('请先登录')
    }
    
    try {
      // 先验证商品是否存在
      const { getProductDetail } = await import('@/api/product')
      let productInfo
      try {
        const response = await getProductDetail(productId)
        productInfo = response.data
        
        // 检查商品状态
        if (!productInfo || productInfo.status !== 1) {
          throw new Error('商品已下架或不存在')
        }
        
        // 检查库存
        if (productInfo.stock < quantity) {
          throw new Error(`库存不足，当前库存：${productInfo.stock}`)
        }
      } catch (error: any) {
        if (error.response?.status === 404 || error.message?.includes('不存在')) {
          throw new Error('商品不存在，可能已被删除')
        }
        throw new Error('获取商品信息失败：' + (error.message || '未知错误'))
      }
      
      const existingItem = cartItems.value.find(item => item.productId === productId)
      
      if (existingItem) {
        // 检查更新后的总数量是否超过库存
        const newQuantity = existingItem.quantity + quantity
        if (newQuantity > productInfo.stock) {
          throw new Error(`库存不足，当前库存：${productInfo.stock}，购物车已有：${existingItem.quantity}`)
        }
        
        // 更新已存在的商品数量
        existingItem.quantity = newQuantity
        existingItem.price = productInfo.price || 0
        existingItem.totalPrice = existingItem.price * existingItem.quantity
        await updateCartItem(existingItem)
      } else {
        // 添加新商品到购物车
        const newItem: Partial<CartItem> = {
          userId: Number(userStore.userInfo.id),
          productId,
          quantity,
          price: productInfo.price || 0,
          totalPrice: (productInfo.price || 0) * quantity
        }
        await saveCartItem(newItem as CartItem)
        await fetchCartItems() // 重新获取购物车列表
      }
    } catch (error: any) {
      console.error('添加到购物车失败:', error)
      // 处理特定的错误情况
      if (error.message?.includes('foreign key constraint')) {
        throw new Error('商品不存在，无法添加到购物车')
      }
      throw error
    }
  }
  
  // 更新购物车商品数量
  const updateQuantity = async (itemId: number, quantity: number) => {
    try {
      const item = cartItems.value.find(item => item.id === itemId)
      if (!item) {
        throw new Error('购物车商品不存在')
      }
      
      if (quantity <= 0) {
        throw new Error('商品数量必须大于0')
      }
      
      // 验证商品是否仍然存在且有足够库存
      const { getProductDetail } = await import('@/api/product')
      try {
        const response = await getProductDetail(item.productId)
        const productInfo = response.data
        
        if (!productInfo || productInfo.status !== 1) {
          throw new Error('商品已下架或不存在，无法更新数量')
        }
        
        if (productInfo.stock < quantity) {
          throw new Error(`库存不足，当前库存：${productInfo.stock}`)
        }
        
        item.quantity = quantity
        item.price = productInfo.price || 0
        item.totalPrice = item.price * quantity
        await updateCartItem(item)
      } catch (error: any) {
        if (error.response?.status === 404) {
          throw new Error('商品不存在，建议从购物车中删除该商品')
        }
        throw error
      }
    } catch (error: any) {
      console.error('更新购物车失败:', error)
      // 处理特定的错误情况
      if (error.message?.includes('foreign key constraint')) {
        throw new Error('商品不存在，无法更新数量')
      }
      throw error
    }
  }
  
  // 删除购物车商品
  const removeFromCart = async (itemIds: number[]) => {
    if (!itemIds || itemIds.length === 0) {
      throw new Error('没有要删除的商品')
    }
    
    try {
      console.log('CartStore: 删除购物车商品，IDs:', itemIds)
      const response = await deleteCartItems(itemIds)
      console.log('CartStore: 删除API响应:', response)
      
      // 检查删除是否成功
      if (response.data && response.data > 0) {
        // 更新本地数据
        cartItems.value = cartItems.value.filter(item => !itemIds.includes(item.id))
        console.log('CartStore: 删除后剩余商品数量:', cartItems.value.length)
      } else {
        throw new Error('删除失败，没有商品被删除')
      }
    } catch (error: any) {
      console.error('删除购物车商品失败:', error)
      throw new Error(error.message || '删除商品失败')
    }
  }
  
  // 清空购物车
  const clearCart = async () => {
    const itemIds = cartItems.value.map(item => item.id)
    if (itemIds.length > 0) {
      await removeFromCart(itemIds)
    }
  }
  
  return {
    // 状态
    cartItems,
    loading,
    // 计算属性
    totalItems,
    totalPrice,
    // 方法
    fetchCartItems,
    addToCart,
    updateQuantity,
    removeFromCart,
    clearCart
  }
}, {
  persist: true
}) 